﻿using System;
using System.Collections.Generic;
using System.Text;

namespace VIX.Enums
{
    #region Enumerations
    /// <summary>
    /// Virtual Machine Capture Screen Format options.
    /// </summary>
    public enum VIX_CAPTURESCREENFORMAT
    {
        PNG = VixCOM.Constants.VIX_CAPTURESCREENFORMAT_PNG,
        PNG_NOCOMPRESS = VixCOM.Constants.VIX_CAPTURESCREENFORMAT_PNG_NOCOMPRESS
    }

    /// <summary>
    /// Virtual Machine Cloning options.
    /// </summary>
    public enum VIX_CLONETYPE
    {
        /// <summary>
        /// Creates a full, independent clone of the virtual machine. 
        /// </summary>
        FULL = VixCOM.Constants.VIX_CLONETYPE_FULL,

        /// <summary>
        /// Creates a linked clone, which is a copy of a virtual machine that shares virtual disks with the parent virtual machine in an ongoing manner. 
        /// This conserves disk space as long as the parent and clone do not change too much from their original state. 
        /// </summary>
        LINKED = VixCOM.Constants.VIX_CLONETYPE_LINKED
    }

    /// <summary>
    /// Error codes returned by the VIX-API functions.
    /// </summary>
    public enum VIX_E
    {
        /// <summary>
        /// The operation was successful.
        /// </summary>
        VIX_OK = VixCOM.Constants.VIX_OK,

        #region General errors
        /// <summary>
        /// Property type mismatch.
        /// </summary>
        PROPERTY_TYPE_MISMATCH = VixCOM.Constants.VIX_E_PROPERTY_TYPE_MISMATCH,
        /// <summary>
        /// No display server.
        /// </summary>
        NO_DISPLAY_SERVER = VixCOM.Constants.VIX_E_NO_DISPLAY_SERVER,
        /// <summary>
        /// Need key.
        /// </summary>
        NEED_KEY = VixCOM.Constants.VIX_E_NEED_KEY,
        /// <summary>
        /// Error license.
        /// </summary>
        LICENSE = VixCOM.Constants.VIX_E_LICENSE,
        /// <summary>
        /// Invalid UTF8 string.
        /// </summary>
        INVALID_UTF8_STRING = VixCOM.Constants.VIX_E_INVALID_UTF8_STRING,
        /// <summary>
        /// Authentification fail.
        /// </summary>
        AUTHENTICATION_FAIL = VixCOM.Constants.VIX_E_AUTHENTICATION_FAIL,
        /// <summary>
        /// Duplicate name.
        /// </summary>
        DUPLICATE_NAME = VixCOM.Constants.VIX_E_DUPLICATE_NAME,
        /// <summary>
        /// Unknown error.
        /// </summary>
        FAIL = VixCOM.Constants.VIX_E_FAIL,
        /// <summary>
        /// Memory allocation failed: out of memory.
        /// </summary>
        OUT_OF_MEMORY = VixCOM.Constants.VIX_E_OUT_OF_MEMORY,
        /// <summary>
        /// One of the parameters was invalid.
        /// </summary>
        INVALID_ARG = VixCOM.Constants.VIX_E_INVALID_ARG,
        /// <summary>
        /// A file was not found.
        /// </summary>
        FILE_NOT_FOUND = VixCOM.Constants.VIX_E_FILE_NOT_FOUND,
        /// <summary>
        /// This function cannot be performed because the handle is executing another function.
        /// </summary>
        OBJECT_IS_BUSY = VixCOM.Constants.VIX_E_OBJECT_IS_BUSY,
        /// <summary>
        /// The operation is not supported for the specified parameters.
        /// </summary>
        NOT_SUPPORTED = VixCOM.Constants.VIX_E_NOT_SUPPORTED,
        /// <summary>
        /// A file access error occurred on the host or guest operating system.
        /// </summary>
        FILE_ERROR = VixCOM.Constants.VIX_E_FILE_ERROR,
        /// <summary>
        /// An error occurred while writing a file; the disk is full. Data has not been saved. Free some space and try again.
        /// </summary>
        DISK_FULL = VixCOM.Constants.VIX_E_DISK_FULL,
        /// <summary>
        /// An error occurred while accessing a file: wrong file type.
        /// </summary>
        INCORRECT_FILE_TYPE = VixCOM.Constants.VIX_E_INCORRECT_FILE_TYPE,
        /// <summary>
        /// The operation was cancelled.
        /// </summary>
        CANCELLED = VixCOM.Constants.VIX_E_CANCELLED,
        /// <summary>
        /// The file is write-protected.
        /// </summary>
        FILE_READ_ONLY = VixCOM.Constants.VIX_E_FILE_READ_ONLY,
        /// <summary>
        /// The file already exists.
        /// </summary>
        FILE_ALREADY_EXISTS = VixCOM.Constants.VIX_E_FILE_ALREADY_EXISTS,
        /// <summary>
        /// You do not have access rights to this file.
        /// </summary>
        FILE_ACCESS_ERROR = VixCOM.Constants.VIX_E_FILE_ACCESS_ERROR,
        /// <summary>
        /// The file system does not support sufficiently large files.
        /// </summary>
        REQUIRES_LARGE_FILES = VixCOM.Constants.VIX_E_REQUIRES_LARGE_FILES,
        /// <summary>
        /// The file is already in use.
        /// </summary>
        FILE_ALREADY_LOCKED = VixCOM.Constants.VIX_E_FILE_ALREADY_LOCKED,
        /// <summary>
        /// The system returned an error. Communication with the virtual machine may have been interrupted.
        /// </summary>
        VMDB = VixCOM.Constants.VIX_E_VMDB,
        /// <summary>
        /// The command is not supported on remote objects.
        /// </summary>
        NOT_SUPPORTED_ON_REMOTE_OBJECT = VixCOM.Constants.VIX_E_NOT_SUPPORTED_ON_REMOTE_OBJECT,
        /// <summary>
        /// The file is too big for the filesystem.
        /// </summary>
        FILE_TOO_BIG = VixCOM.Constants.VIX_E_FILE_TOO_BIG,
        /// <summary>
        /// The file name is not valid.
        /// </summary>
        FILE_NAME_INVALID = VixCOM.Constants.VIX_E_FILE_NAME_INVALID,
        /// <summary>
        /// Already exists.
        /// </summary>
        ALREADY_EXISTS = VixCOM.Constants.VIX_E_ALREADY_EXISTS,
        /// <summary>
        /// Buffer is too small.
        /// </summary>
        BUFFER_TOOSMALL = VixCOM.Constants.VIX_E_BUFFER_TOOSMALL,
        /// <summary>
        /// The request refers to an object that no longer exists or has never existed.
        /// </summary>
        OBJECT_NOT_FOUND = VixCOM.Constants.VIX_E_OBJECT_NOT_FOUND,
        /// <summary>
        /// Unable to connect to the host.
        /// </summary>
        HOST_NOT_CONNECTED = VixCOM.Constants.VIX_E_HOST_NOT_CONNECTED,
        /// <summary>
        /// Job has not finished yet.
        /// </summary>
        UNFINISHED_JOB = VixCOM.Constants.VIX_E_UNFINISHED_JOB,
        #endregion

        #region Handle Errors
        /// <summary>
        /// The handle is not a valid VIX object.
        /// </summary>
        INVALID_HANDLE = VixCOM.Constants.VIX_E_INVALID_HANDLE,
        /// <summary>
        /// The operation is not supported on this type of handle.
        /// </summary>
        NOT_SUPPORTED_ON_HANDLE_TYPE = VixCOM.Constants.VIX_E_NOT_SUPPORTED_ON_HANDLE_TYPE,
        /// <summary>
        /// Too many handles are open.
        /// </summary>
        TOO_MANY_HANDLES = VixCOM.Constants.VIX_E_TOO_MANY_HANDLES,
        #endregion

        #region XML errors
        /// <summary>
        /// Invalid file - a required section of the file is missing.
        /// </summary>
        NOT_FOUND = VixCOM.Constants.VIX_E_NOT_FOUND,
        /// <summary>
        /// Invalid file - an object has the wrong type.
        /// </summary>
        TYPE_MISMATCH = VixCOM.Constants.VIX_E_TYPE_MISMATCH,
        /// <summary>
        /// Invalid file - contents may be corrupt.
        /// </summary>
        INVALID_XML = VixCOM.Constants.VIX_E_INVALID_XML,
        #endregion

        #region VM Control Errors
        /// <summary>
        /// Timeout error while waiting for the guest tools to start.
        /// </summary>
        TIMEOUT_WAITING_FOR_TOOLS = VixCOM.Constants.VIX_E_TIMEOUT_WAITING_FOR_TOOLS,
        /// <summary>
        /// The command is not recognized by the virtual machine.
        /// </summary>
        UNRECOGNIZED_COMMAND = VixCOM.Constants.VIX_E_UNRECOGNIZED_COMMAND,
        /// <summary>
        /// The requested operation is not supported on this guest operating system.
        /// </summary>
        OP_NOT_SUPPORTED_ON_GUEST = VixCOM.Constants.VIX_E_OP_NOT_SUPPORTED_ON_GUEST,
        /// <summary>
        /// A program could not run on the guest operating system.
        /// </summary>
        PROGRAM_NOT_STARTED = VixCOM.Constants.VIX_E_PROGRAM_NOT_STARTED,
        /// <summary>
        /// Cannot power on a read-only virtual machine.
        /// </summary>
        CANNOT_START_READ_ONLY_VM = VixCOM.Constants.VIX_E_CANNOT_START_READ_ONLY_VM,
        /// <summary>
        /// The virtual machine needs to be powered on.
        /// </summary>
        VM_NOT_RUNNING = VixCOM.Constants.VIX_E_VM_NOT_RUNNING,
        /// <summary>
        /// The virtual machine is not recording.
        /// </summary>
        VM_NOT_RECORDING = VixCOM.Constants.VIX_E_VM_NOT_RECORDING,
        /// <summary>
        /// The virtual machine is not replaying.
        /// </summary>
        VM_NOT_REPLAYING = VixCOM.Constants.VIX_E_VM_NOT_REPLAYING,
        /// <summary>
        /// The virtual machine should not be powered on. It appears to be running already.
        /// </summary>
        VM_IS_RUNNING = VixCOM.Constants.VIX_E_VM_IS_RUNNING,
        /// <summary>
        /// Cannot connect to the virtual machine.
        /// </summary>
        CANNOT_CONNECT_TO_VM = VixCOM.Constants.VIX_E_CANNOT_CONNECT_TO_VM,
        /// <summary>
        /// Cannot execute scripts.
        /// </summary>
        POWEROP_SCRIPTS_NOT_AVAILABLE = VixCOM.Constants.VIX_E_POWEROP_SCRIPTS_NOT_AVAILABLE,
        /// <summary>
        /// No operating system installed in the virtual machine.
        /// </summary>
        NO_GUEST_OS_INSTALLED = VixCOM.Constants.VIX_E_NO_GUEST_OS_INSTALLED,
        /// <summary>
        /// Not enough physical memory is available to power on this virtual machine.
        /// </summary>
        VM_INSUFFICIENT_HOST_MEMORY = VixCOM.Constants.VIX_E_VM_INSUFFICIENT_HOST_MEMORY,
        /// <summary>
        /// An error occurred while suspending the virtual machine.
        /// </summary>
        SUSPEND_ERROR = VixCOM.Constants.VIX_E_SUSPEND_ERROR,
        /// <summary>
        /// This virtual machine is configured to run with 2 CPUs, but the host only has 1 CPU. The virtual machine cannot be powered on.
        /// </summary>
        VM_NOT_ENOUGH_CPUS = VixCOM.Constants.VIX_E_VM_NOT_ENOUGH_CPUS,
        /// <summary>
        /// Insufficient permissions in host operating system.
        /// </summary>
        HOST_USER_PERMISSIONS = VixCOM.Constants.VIX_E_HOST_USER_PERMISSIONS,
        /// <summary>
        /// Authentication failure or insufficient permissions in guest operating system.
        /// </summary>
        GUEST_USER_PERMISSIONS = VixCOM.Constants.VIX_E_GUEST_USER_PERMISSIONS,
        /// <summary>
        /// Guest operations are not allowed on this virtual machine.
        /// </summary>
        GUEST_OPERATIONS_PROHIBITED = VixCOM.Constants.VIX_E_GUEST_OPERATIONS_PROHIBITED,
        /// <summary>
        /// Guest operations are not allowed for the anonymous user on this virtual machine.
        /// </summary>
        ANON_GUEST_OPERATIONS_PROHIBITED = VixCOM.Constants.VIX_E_ANON_GUEST_OPERATIONS_PROHIBITED,
        /// <summary>
        /// Guest operations are not allowed for administrative user on this virtual machine.
        /// </summary>
        ROOT_GUEST_OPERATIONS_PROHIBITED = VixCOM.Constants.VIX_E_ROOT_GUEST_OPERATIONS_PROHIBITED,
        /// <summary>
        /// The virtual machine configuration must specify guest account name to be used for anonymous guest operations.
        /// </summary>
        MISSING_ANON_GUEST_ACCOUNT = VixCOM.Constants.VIX_E_MISSING_ANON_GUEST_ACCOUNT,
        /// <summary>
        /// The virtual machine cannot authenticate users with guest.
        /// </summary>
        CANNOT_AUTHENTICATE_WITH_GUEST = VixCOM.Constants.VIX_E_CANNOT_AUTHENTICATE_WITH_GUEST,
        /// <summary>
        /// The command is not recognized by the Guest OS tools.
        /// </summary>
        UNRECOGNIZED_COMMAND_IN_GUEST = VixCOM.Constants.VIX_E_UNRECOGNIZED_COMMAND_IN_GUEST,
        /// <summary>
        /// Guest operations are not allowed for console user on this virtual machine.
        /// </summary>
        CONSOLE_GUEST_OPERATIONS_PROHIBITED = VixCOM.Constants.VIX_E_CONSOLE_GUEST_OPERATIONS_PROHIBITED,
        /// <summary>
        /// The command can only be run by console user.
        /// </summary>
        MUST_BE_CONSOLE_USER = VixCOM.Constants.VIX_E_MUST_BE_CONSOLE_USER,
        /// <summary>
        /// The virtual machine is blocked waiting for a user operation.
        /// </summary>
        VMX_MSG_DIALOG_AND_NO_UI = VixCOM.Constants.VIX_E_VMX_MSG_DIALOG_AND_NO_UI,
        /// <summary>
        /// Not allowed while the virtual machine is recording.
        /// </summary>
        NOT_ALLOWED_DURING_VM_RECORDING = VixCOM.Constants.VIX_E_NOT_ALLOWED_DURING_VM_RECORDING,
        /// <summary>
        /// Not allowed while the virtual machine is replaying.
        /// </summary>
        NOT_ALLOWED_DURING_VM_REPLAY = VixCOM.Constants.VIX_E_NOT_ALLOWED_DURING_VM_REPLAY,
        /// <summary>
        /// Operation is already in progress.
        /// </summary>
        OPERATION_ALREADY_IN_PROGRESS = VixCOM.Constants.VIX_E_OPERATION_ALREADY_IN_PROGRESS,
        /// <summary>
        /// The command is not allowed by this login type.
        /// </summary>
        OPERATION_NOT_ALLOWED_FOR_LOGIN_TYPE = VixCOM.Constants.VIX_E_OPERATION_NOT_ALLOWED_FOR_LOGIN_TYPE,
        /// <summary>
        /// This login type is not supported.
        /// </summary>
        LOGIN_TYPE_NOT_SUPPORTED = VixCOM.Constants.VIX_E_LOGIN_TYPE_NOT_SUPPORTED,
        /// <summary>
        /// The guest does not support empty passwords.
        /// </summary>
        EMPTY_PASSWORD_NOT_ALLOWED_IN_GUEST = VixCOM.Constants.VIX_E_EMPTY_PASSWORD_NOT_ALLOWED_IN_GUEST,
        /// <summary>
        /// The specified guest user must be logged in interactively to perform this operation.
        /// </summary>
        INTERACTIVE_SESSION_NOT_PRESENT = VixCOM.Constants.VIX_E_INTERACTIVE_SESSION_NOT_PRESENT,
        /// <summary>
        /// The specified guest user does not match the user currently logged in interactively.
        /// </summary>
        INTERACTIVE_SESSION_USER_MISMATCH = VixCOM.Constants.VIX_E_INTERACTIVE_SESSION_USER_MISMATCH,
        /// <summary>
        /// Unable to replay the virtual machine.
        /// </summary>
        UNABLE_TO_REPLAY_VM = VixCOM.Constants.VIX_E_UNABLE_TO_REPLAY_VM,
        #endregion

        #region VM Guest Tools
        /// <summary>
        /// Guest tools already up to date.
        /// </summary>
        TOOLS_INSTALL_ALREADY_UP_TO_DATE = VixCOM.Constants.VIX_E_TOOLS_INSTALL_ALREADY_UP_TO_DATE,
        /// <summary>
        /// Guest tools install auto not supported.
        /// </summary>
        TOOLS_INSTALL_AUTO_NOT_SUPPORTED = VixCOM.Constants.VIX_E_TOOLS_INSTALL_AUTO_NOT_SUPPORTED,
        /// <summary>
        /// Guest tools install cancelled.
        /// </summary>
        TOOLS_INSTALL_CANCELLED = VixCOM.Constants.VIX_E_TOOLS_INSTALL_CANCELLED,
        /// <summary>
        /// Guest tools install device not connected.
        /// </summary>
        TOOLS_INSTALL_DEVICE_NOT_CONNECTED = VixCOM.Constants.VIX_E_TOOLS_INSTALL_DEVICE_NOT_CONNECTED,
        /// <summary>
        /// Guest tools install error.
        /// </summary>
        TOOLS_INSTALL_ERROR = VixCOM.Constants.VIX_E_TOOLS_INSTALL_ERROR,
        /// <summary>
        /// Guest tools install guest not ready.
        /// </summary>
        TOOLS_INSTALL_GUEST_NOT_READY = VixCOM.Constants.VIX_E_TOOLS_INSTALL_GUEST_NOT_READY,
        /// <summary>
        /// Guest tools install image inaccesible.
        /// </summary>
        TOOLS_INSTALL_IMAGE_INACCESIBLE = VixCOM.Constants.VIX_E_TOOLS_INSTALL_IMAGE_INACCESIBLE,
        /// <summary>
        /// Guest tools ontals in progress.
        /// </summary>
        TOOLS_INSTALL_IN_PROGRESS = VixCOM.Constants.VIX_E_TOOLS_INSTALL_IN_PROGRESS,
        /// <summary>
        /// Guest tools install init failed.
        /// </summary>
        TOOLS_INSTALL_INIT_FAILED = VixCOM.Constants.VIX_E_TOOLS_INSTALL_INIT_FAILED,
        /// <summary>
        /// Guest tools install no device.
        /// </summary>
        TOOLS_INSTALL_NO_DEVICE = VixCOM.Constants.VIX_E_TOOLS_INSTALL_NO_DEVICE,
        /// <summary>
        /// Guest tools install no image.
        /// </summary>
        TOOLS_INSTALL_NO_IMAGE = VixCOM.Constants.VIX_E_TOOLS_INSTALL_NO_IMAGE,
        /// <summary>
        /// Guest tools install sig check failed.
        /// </summary>
        TOOLS_INSTALL_SIG_CHECK_FAILED = VixCOM.Constants.VIX_E_TOOLS_INSTALL_SIG_CHECK_FAILED,
        /// <summary>
        /// Guest tools is not running.
        /// </summary>
        TOOLS_NOT_RUNNING = VixCOM.Constants.VIX_E_TOOLS_NOT_RUNNING,
        #endregion

        #region VM Errors
        /// <summary>
        /// The virtual machine cannot be found.
        /// </summary>
        VM_NOT_FOUND = VixCOM.Constants.VIX_E_VM_NOT_FOUND,
        /// <summary>
        /// The operation is not supported for this virtual machine version.
        /// </summary>
        NOT_SUPPORTED_FOR_VM_VERSION = VixCOM.Constants.VIX_E_NOT_SUPPORTED_FOR_VM_VERSION,
        /// <summary>
        /// Cannot read the virtual machine configuration file.
        /// </summary>
        CANNOT_READ_VM_CONFIG = VixCOM.Constants.VIX_E_CANNOT_READ_VM_CONFIG,
        /// <summary>
        /// Cannot perform this operation on a template virtual machine.
        /// </summary>
        TEMPLATE_VM = VixCOM.Constants.VIX_E_TEMPLATE_VM,
        /// <summary>
        /// The virtual machine has already been loaded.
        /// </summary>
        VM_ALREADY_LOADED = VixCOM.Constants.VIX_E_VM_ALREADY_LOADED,
        /// <summary>
        /// The virtual machine is already up-to-date.
        /// </summary>
        VM_ALREADY_UP_TO_DATE = VixCOM.Constants.VIX_E_VM_ALREADY_UP_TO_DATE,
        #endregion

        #region Property Errors
        /// <summary>
        /// Unrecognized handle property identifier.
        /// </summary>
        UNRECOGNIZED_PROPERTY = VixCOM.Constants.VIX_E_UNRECOGNIZED_PROPERTY,
        /// <summary>
        /// Invalid property value.
        /// </summary>
        INVALID_PROPERTY_VALUE = VixCOM.Constants.VIX_E_INVALID_PROPERTY_VALUE,
        /// <summary>
        /// Cannot change a read-only property.
        /// </summary>
        READ_ONLY_PROPERTY = VixCOM.Constants.VIX_E_READ_ONLY_PROPERTY,
        /// <summary>
        /// This handle is missing a required property.
        /// </summary>
        MISSING_REQUIRED_PROPERTY = VixCOM.Constants.VIX_E_MISSING_REQUIRED_PROPERTY,
        /// <summary>
        /// A serialized object is invalid and cannot be deserialized.
        /// </summary>
        INVALID_SERIALIZED_DATA = VixCOM.Constants.VIX_E_INVALID_SERIALIZED_DATA,
        #endregion

        #region Completion Errors
        /// <summary>
        /// The index parameter does not correspond to a result set.
        /// </summary>
        BAD_VM_INDEX = VixCOM.Constants.VIX_E_BAD_VM_INDEX,
        #endregion

        #region Message errors
        /// <summary>
        /// A message header was corrupted or has the incorrect version.
        /// </summary>
        INVALID_MESSAGE_HEADER = VixCOM.Constants.VIX_E_INVALID_MESSAGE_HEADER,
        /// <summary>
        /// A message body was corrupted or is missing.
        /// </summary>
        INVALID_MESSAGE_BODY = VixCOM.Constants.VIX_E_INVALID_MESSAGE_BODY,
        #endregion

        #region Snapshot errors
        /// <summary>
        /// Minimum free space.
        /// </summary>
        SNAPSHOT_MIN_FREE_SPACE = VixCOM.Constants.VIX_E_SNAPSHOT_MIN_FREE_SPACE,
        /// <summary>
        /// Max snapshots.
        /// </summary>
        SNAPSHOT_MAXSNAPSHOTS = VixCOM.Constants.VIX_E_SNAPSHOT_MAXSNAPSHOTS,
        /// <summary>
        /// Hierarchy too deep.
        /// </summary>
        SNAPSHOT_HIERARHCY_TOODEEP = VixCOM.Constants.VIX_E_SNAPSHOT_HIERARCHY_TOODEEP,
        /// <summary>
        /// The snapshot is incompatable with the current host.
        /// </summary>
        SNAPSHOT_INVAL = VixCOM.Constants.VIX_E_SNAPSHOT_INVAL,
        /// <summary>
        /// Unable to open snapshot file.
        /// </summary>
        SNAPSHOT_DUMPER = VixCOM.Constants.VIX_E_SNAPSHOT_DUMPER,
        /// <summary>
        /// Disk problem.
        /// </summary>
        SNAPSHOT_DISKLIB = VixCOM.Constants.VIX_E_SNAPSHOT_DISKLIB,
        /// <summary>
        /// A file by that name does not exist.
        /// </summary>
        SNAPSHOT_NOTFOUND = VixCOM.Constants.VIX_E_SNAPSHOT_NOTFOUND,
        /// <summary>
        /// A file by that name already exists.
        /// </summary>
        SNAPSHOT_EXISTS = VixCOM.Constants.VIX_E_SNAPSHOT_EXISTS,
        /// <summary>
        /// Snapshots are not allowed on this virtual machine.
        /// </summary>
        SNAPSHOT_VERSION = VixCOM.Constants.VIX_E_SNAPSHOT_VERSION,
        /// <summary>
        /// Insufficient permissions.
        /// </summary>
        SNAPSHOT_NOPERM = VixCOM.Constants.VIX_E_SNAPSHOT_NOPERM,
        /// <summary>
        /// Something is wrong with the configuration file.
        /// </summary>
        SNAPSHOT_CONFIG = VixCOM.Constants.VIX_E_SNAPSHOT_CONFIG,
        /// <summary>
        /// The state of the virtual machine has not changed since the last snapshot operation.
        /// </summary>
        SNAPSHOT_NOCHANGE = VixCOM.Constants.VIX_E_SNAPSHOT_NOCHANGE,
        /// <summary>
        /// Unable to save snapshot file.
        /// </summary>
        SNAPSHOT_CHECKPOINT = VixCOM.Constants.VIX_E_SNAPSHOT_CHECKPOINT,
        /// <summary>
        /// A snapshot operation is already in progress.
        /// </summary>
        SNAPSHOT_LOCKED = VixCOM.Constants.VIX_E_SNAPSHOT_LOCKED,
        /// <summary>
        /// The snapshot files are in an inconsistent state.
        /// </summary>
        SNAPSHOT_INCONSISTENT = VixCOM.Constants.VIX_E_SNAPSHOT_INCONSISTENT,
        /// <summary>
        /// The filename is too long.
        /// </summary>
        SNAPSHOT_NAMETOOLONG = VixCOM.Constants.VIX_E_SNAPSHOT_NAMETOOLONG,
        /// <summary>
        /// Cannot snapshot all metadata files.
        /// </summary>
        SNAPSHOT_VIXFILE = VixCOM.Constants.VIX_E_SNAPSHOT_VIXFILE,
        /// <summary>
        /// One or more of the disks are busy.
        /// </summary>
        SNAPSHOT_DISKLOCKED = VixCOM.Constants.VIX_E_SNAPSHOT_DISKLOCKED,
        /// <summary>
        /// The virtual disk is used multiple times.
        /// </summary>
        SNAPSHOT_DUPLICATEDDISK = VixCOM.Constants.VIX_E_SNAPSHOT_DUPLICATEDDISK,
        /// <summary>
        /// Powered on snapshot are not allowed on virtual machines with indpendent disks.
        /// </summary>
        SNAPSHOT_INDEPENDENTDISK = VixCOM.Constants.VIX_E_SNAPSHOT_INDEPENDENTDISK,
        /// <summary>
        /// The name does not uniquely identify one snapshot.
        /// </summary>
        SNAPSHOT_NONUNIQUE_NAME = VixCOM.Constants.VIX_E_SNAPSHOT_NONUNIQUE_NAME,
        /// <summary>
        /// Failed to take a memory snapshot, since the virtual machine is configured with independent disks.
        /// </summary>
        SNAPSHOT_MEMORY_ON_INDEPENDENT_DISK = VixCOM.Constants.VIX_E_SNAPSHOT_MEMORY_ON_INDEPENDENT_DISK,
        #endregion

        #region Host Errors
        /// <summary>
        /// Connection lost.
        /// </summary>
        HOST_CONNECTION_LOST = VixCOM.Constants.VIX_E_HOST_CONNECTION_LOST,
        /// <summary>
        /// The specified device is not a valid physical disk device.
        /// </summary>
        HOST_DISK_INVALID_VALUE = VixCOM.Constants.VIX_E_HOST_DISK_INVALID_VALUE,
        /// <summary>
        /// Disk sector size check failed.
        /// </summary>
        HOST_DISK_SECTORSIZE = VixCOM.Constants.VIX_E_HOST_DISK_SECTORSIZE,
        /// <summary>
        /// Read beyond the end of file.
        /// </summary>
        HOST_FILE_ERROR_EOF = VixCOM.Constants.VIX_E_HOST_FILE_ERROR_EOF,
        /// <summary>
        /// Error in protocol.
        /// </summary>
        HOST_NETBLKDEV_HANDSHAKE = VixCOM.Constants.VIX_E_HOST_NETBLKDEV_HANDSHAKE,
        /// <summary>
        /// Unable to create socket.
        /// </summary>
        HOST_SOCKET_CREATION_ERROR = VixCOM.Constants.VIX_E_HOST_SOCKET_CREATION_ERROR,
        /// <summary>
        /// The specified server could not be contacted.
        /// </summary>
        HOST_SERVER_NOT_FOUND = VixCOM.Constants.VIX_E_HOST_SERVER_NOT_FOUND,
        /// <summary>
        /// The server refused connection.
        /// </summary>
        HOST_NETWORK_CONN_REFUSED = VixCOM.Constants.VIX_E_HOST_NETWORK_CONN_REFUSED,
        /// <summary>
        /// There was an error in communication.
        /// </summary>
        HOST_TCP_SOCKET_ERROR = VixCOM.Constants.VIX_E_HOST_TCP_SOCKET_ERROR,
        /// <summary>
        /// The connection was lost.
        /// </summary>
        HOST_TCP_CONN_LOST = VixCOM.Constants.VIX_E_HOST_TCP_CONN_LOST,
        /// <summary>
        /// NBD_ERR_HASHFILE_VOLUME.
        /// </summary>
        HOST_NBD_HASHFILE_VOLUME = VixCOM.Constants.VIX_E_HOST_NBD_HASHFILE_VOLUME,
        /// <summary>
        /// NBD_ERR_HASHFILE_INIT.
        /// </summary>
        HOST_NBD_HASHFILE_INIT = VixCOM.Constants.VIX_E_HOST_NBD_HASHFILE_INIT,
        #endregion

        #region Disklib errors
        /// <summary>
        /// One of the parameters supplied is invalid.
        /// </summary>
        DISK_INVAL = VixCOM.Constants.VIX_E_DISK_INVAL,
        /// <summary>
        /// The disk library has not been initialized.
        /// </summary>
        DISK_NOINIT = VixCOM.Constants.VIX_E_DISK_NOINIT,
        /// <summary>
        /// The called function requires the virtual disk to be opened for I/O.
        /// </summary>
        DISK_NOIO = VixCOM.Constants.VIX_E_DISK_NOIO,
        /// <summary>
        /// The called function cannot be performed on partial chains. Please open the parent virtual disk.
        /// </summary>
        DISK_PARTIALCHAIN = VixCOM.Constants.VIX_E_DISK_PARTIALCHAIN,
        /// <summary>
        /// The specified virtual disk needs repair.
        /// </summary>
        DISK_NEEDSREPAIR = VixCOM.Constants.VIX_E_DISK_NEEDSREPAIR,
        /// <summary>
        /// You have requested access to an area of the virtual disk that is out of bounds.
        /// </summary>
        DISK_OUTOFRANGE = VixCOM.Constants.VIX_E_DISK_OUTOFRANGE,
        /// <summary>
        /// The parent virtual disk has been modified since the child was created.
        /// </summary>
        DISK_CID_MISMATCH = VixCOM.Constants.VIX_E_DISK_CID_MISMATCH,
        /// <summary>
        /// The specified virtual disk cannot be shrunk because it is not the parent disk.
        /// </summary>
        DISK_CANTSHRINK = VixCOM.Constants.VIX_E_DISK_CANTSHRINK,
        /// <summary>
        /// The partition table on the physical disk has changed since the disk was created. Remove the physical disk from the virtual machine, then add it again.
        /// </summary>
        DISK_PARTMISMATCH = VixCOM.Constants.VIX_E_DISK_PARTMISMATCH,
        /// <summary>
        /// than the version supported by this program. 
        /// </summary>
        DISK_UNSUPPORTEDDISKVERSION = VixCOM.Constants.VIX_E_DISK_UNSUPPORTEDDISKVERSION,
        /// <summary>
        /// The parent of this virtual disk could not be opened.
        /// </summary>
        DISK_OPENPARENT = VixCOM.Constants.VIX_E_DISK_OPENPARENT,
        /// <summary>
        /// The specified feature isn't supported by this version.
        /// </summary>
        DISK_NOTSUPPORTED = VixCOM.Constants.VIX_E_DISK_NOTSUPPORTED,
        /// <summary>
        /// One or more required keys were not provided.
        /// </summary>
        DISK_NEEDKEY = VixCOM.Constants.VIX_E_DISK_NEEDKEY,
        /// <summary>
        /// Won't create unencrypted child of encrypted disk without explicit request.
        /// </summary>
        DISK_NOKEYOVERRIDE = VixCOM.Constants.VIX_E_DISK_NOKEYOVERRIDE,
        /// <summary>
        /// Not an encrypted disk.
        /// </summary>
        DISK_NOTENCRYPTED = VixCOM.Constants.VIX_E_DISK_NOTENCRYPTED,
        /// <summary>
        /// No keys supplied for encrypting disk.
        /// </summary>
        DISK_NOKEY = VixCOM.Constants.VIX_E_DISK_NOKEY,
        /// <summary>
        /// The partition table is invalid.
        /// </summary>
        DISK_INVALIDPARTITIONTABLE = VixCOM.Constants.VIX_E_DISK_INVALIDPARTITIONTABLE,
        /// <summary>
        /// Only sparse extents with embedded descriptors may be encrypted.
        /// </summary>
        DISK_NOTNORMAL = VixCOM.Constants.VIX_E_DISK_NOTNORMAL,
        /// <summary>
        /// Not an encrypted descriptor file.
        /// </summary>
        DISK_NOTENCDESC = VixCOM.Constants.VIX_E_DISK_NOTENCDESC,
        /// <summary>
        /// File system isn't VMFS.
        /// </summary>
        DISK_NEEDVMFS = VixCOM.Constants.VIX_E_DISK_NEEDVMFS,
        /// <summary>
        /// The physical disk is too big. The maximum size allowed is 2TB.
        /// </summary>
        DISK_RAWTOOBIG = VixCOM.Constants.VIX_E_DISK_RAWTOOBIG,
        /// <summary>
        /// The host's limit for open files has been exceeded.
        /// </summary>
        DISK_TOOMANYOPENFILES = VixCOM.Constants.VIX_E_DISK_TOOMANYOPENFILES,
        /// <summary>
        /// Too many levels of redo logs.
        /// </summary>
        DISK_TOOMANYREDO = VixCOM.Constants.VIX_E_DISK_TOOMANYREDO,
        /// <summary>
        /// The physical disk is too small.
        /// </summary>
        DISK_RAWTOOSMALL = VixCOM.Constants.VIX_E_DISK_RAWTOOSMALL,
        /// <summary>
        /// Invalid disk chain: cannot mix hosted and managed style disks in the same chain.
        /// </summary>
        DISK_INVALIDCHAIN = VixCOM.Constants.VIX_E_DISK_INVALIDCHAIN,
        /// <summary>
        /// The specified key is not found in the disk data base.
        /// </summary>
        DISK_KEY_NOTFOUND = VixCOM.Constants.VIX_E_DISK_KEY_NOTFOUND,
        /// <summary>
        /// One or more required subsystems failed to initialize.
        /// </summary>
        DISK_SUBSYSTEM_INIT_FAIL = VixCOM.Constants.VIX_E_DISK_SUBSYSTEM_INIT_FAIL,
        /// <summary>
        /// Invalid connection handle.
        /// </summary>
        DISK_INVALID_CONNECTION = VixCOM.Constants.VIX_E_DISK_INVALID_CONNECTION,
        /// <summary>
        /// Disk Encoding error.
        /// </summary>
        DISK_ENCODING = VixCOM.Constants.VIX_E_DISK_ENCODING,
        /// <summary>
        /// Disk is corrupted and unrepairable.
        /// </summary>
        DISK_CANTREPAIR = VixCOM.Constants.VIX_E_DISK_CANTREPAIR,
        /// <summary>
        /// The specified file is not a virtual disk.
        /// </summary>
        DISK_INVALIDDISK = VixCOM.Constants.VIX_E_DISK_INVALIDDISK,
        /// <summary>
        /// Host is not licensed for this feature.
        /// </summary>
        DISK_NOLICENSE = VixCOM.Constants.VIX_E_DISK_NOLICENSE,
        /// <summary>
        /// The disk drive is unsupported by this program. 
        /// </summary>
        DISK_UNSUPPORTEDDEVIDE = VixCOM.Constants.VIX_E_DISK_UNSUPPORTEDDEVICE,
        #endregion

        #region Crypto Library Errors
        /// <summary>
        /// Security library error.
        /// </summary>
        CRYPTO_UNKNOWN_ALGORITHM = VixCOM.Constants.VIX_E_CRYPTO_UNKNOWN_ALGORITHM,
        /// <summary>
        /// Security library error.
        /// </summary>
        CRYPTO_BAD_BUFFER_SIZE = VixCOM.Constants.VIX_E_CRYPTO_BAD_BUFFER_SIZE,
        /// <summary>
        /// Security library error.
        /// </summary>
        CRYPTO_INVALID_OPERATION = VixCOM.Constants.VIX_E_CRYPTO_INVALID_OPERATION,
        /// <summary>
        /// Security library error.
        /// </summary>
        CRYPTO_RANDOM_DEVICE = VixCOM.Constants.VIX_E_CRYPTO_RANDOM_DEVICE,
        /// <summary>
        /// Security library error.
        /// </summary>
        CRYPTO_NEED_PASSWORD = VixCOM.Constants.VIX_E_CRYPTO_NEED_PASSWORD,
        /// <summary>
        /// Security library error.
        /// </summary>
        CRYPTO_BAD_PASSWORD = VixCOM.Constants.VIX_E_CRYPTO_BAD_PASSWORD,
        /// <summary>
        /// Security library error.
        /// </summary>
        CRYPTO_NOT_IN_DICTIONARY = VixCOM.Constants.VIX_E_CRYPTO_NOT_IN_DICTIONARY,
        /// <summary>
        /// Security library error.
        /// </summary>
        CRYPTO_NO_CRYPTO = VixCOM.Constants.VIX_E_CRYPTO_NO_CRYPTO,
        /// <summary>
        /// Security library error.
        /// </summary>
        CRYPTO_ERROR = VixCOM.Constants.VIX_E_CRYPTO_ERROR,
        /// <summary>
        /// Security library error.
        /// </summary>
        CRYPTO_BAD_FORMAT = VixCOM.Constants.VIX_E_CRYPTO_BAD_FORMAT,
        /// <summary>
        /// Security library error.
        /// </summary>
        CRYPTO_LOCKED = VixCOM.Constants.VIX_E_CRYPTO_LOCKED,
        /// <summary>
        /// Security library error.
        /// </summary>
        CRYPTO_EMPTY = VixCOM.Constants.VIX_E_CRYPTO_EMPTY,
        /// <summary>
        /// Security library error.
        /// </summary>
        CRYPTO_KEYSAFE_LOCATOR = VixCOM.Constants.VIX_E_CRYPTO_KEYSAFE_LOCATOR,
        #endregion

        #region Remoting Errors
        /// <summary>
        /// Cannot connect to host.
        /// </summary>
        CANNOT_CONNECT_TO_HOST = VixCOM.Constants.VIX_E_CANNOT_CONNECT_TO_HOST,
        /// <summary>
        /// This feature can only be supported on local host.
        /// </summary>
        NOT_FOR_REMOTE_HOST = VixCOM.Constants.VIX_E_NOT_FOR_REMOTE_HOST,
        /// <summary>
        /// Malformed hostname parameter. For the given service provider, the hostname must be a URL, in the form https://:/sdk.
        /// </summary>
        INVALID_HOSTNAME_SPECIFICATION = VixCOM.Constants.VIX_E_INVALID_HOSTNAME_SPECIFICATION,
        #endregion

        #region Screen Capture Errors
        /// <summary>
        /// Could not capture screen.
        /// </summary>
        SCREEN_CAPTURE_ERROR = VixCOM.Constants.VIX_E_SCREEN_CAPTURE_ERROR,
        /// <summary>
        /// Requested unsupported format.
        /// </summary>
        SCREEN_CAPTURE_BAD_FORMAT = VixCOM.Constants.VIX_E_SCREEN_CAPTURE_BAD_FORMAT,
        /// <summary>
        /// Could not compress screen capture.
        /// </summary>
        SCREEN_CAPTURE_COMPRESSION_FAIL = VixCOM.Constants.VIX_E_SCREEN_CAPTURE_COMPRESSION_FAIL,
        /// <summary>
        /// The screen capture data is larger than the given maximum size.
        /// </summary>
        SCREEN_CAPTURE_LARGE_DATA = VixCOM.Constants.VIX_E_SCREEN_CAPTURE_LARGE_DATA,
        #endregion

        #region Guest Errors
        /// <summary>
        /// Drives are not frozen.
        /// </summary>
        GUEST_VOLUMES_NOT_FROZEN = VixCOM.Constants.VIX_E_GUEST_VOLUMES_NOT_FROZEN,
        /// <summary>
        /// The object is not a file.
        /// </summary>
        NOT_A_FILE = VixCOM.Constants.VIX_E_NOT_A_FILE,
        /// <summary>
        /// The object is not a directory.
        /// </summary>
        NOT_A_DIRECTORY = VixCOM.Constants.VIX_E_NOT_A_DIRECTORY,
        /// <summary>
        /// No such process.
        /// </summary>
        NO_SUCH_PROCESS = VixCOM.Constants.VIX_E_NO_SUCH_PROCESS,
        /// <summary>
        /// File name too long.
        /// </summary>
        FILE_NAME_TOO_LONG = VixCOM.Constants.VIX_E_FILE_NAME_TOO_LONG,
        #endregion

        #region MNTAPI
        /// <summary>
        /// A handle to the Volume or DiskSet is already open.
        /// </summary>
        MNTAPI_ALREADY_OPENED = VixCOM.Constants.VIX_E_MNTAPI_ALREADY_OPENED,
        /// <summary>
        /// Cannot create directory '/var/run/vmware/fuse'.
        /// </summary>
        MNTAPI_CANT_MAKE_VAR_DIR = VixCOM.Constants.VIX_E_MNTAPI_CANT_MAKE_VAR_DIR,
        /// <summary>
        /// Cannot read or parse the partition table on the virtual disk.
        /// </summary>
        MNTAPI_CANT_READ_PARTS = VixCOM.Constants.VIX_E_MNTAPI_CANT_READ_PARTS,
        /// <summary>
        /// Error converting string.
        /// </summary>
        MNTAPI_CODECONVERSION = VixCOM.Constants.VIX_E_MNTAPI_CODECONVERSION,
        /// <summary>
        /// There was an error while creating the partition table.
        /// </summary>
        MNTAPI_CREATE_PARTITIONTABLE_ERROR = VixCOM.Constants.VIX_E_MNTAPI_CREATE_PARTITIONTABLE_ERROR,
        /// <summary>
        /// The VMware fuse daemon failed to start.
        /// </summary>
        MNTAPI_DAEMON = VixCOM.Constants.VIX_E_MNTAPI_DAEMON,
        /// <summary>
        /// Error accessing metadata. You may not have sufficient permission to access this disk or the metadata may be corrupted.
        /// </summary>
        MNTAPI_DICT = VixCOM.Constants.VIX_E_MNTAPI_DICT,
        /// <summary>
        /// The metadata for this disk is locked. Please check for other virtual disk mounter applicaitons running.
        /// </summary>
        MNTAPI_DICT_LOCKED = VixCOM.Constants.VIX_E_MNTAPI_DICT_LOCKED,
        /// <summary>
        /// Cannot open the virtual disk.
        /// </summary>
        MNTAPI_DISK_CANT_OPEN = VixCOM.Constants.VIX_E_MNTAPI_DISK_CANT_OPEN,
        /// <summary>
        /// The specified disk is already mounted.
        /// </summary>
        MNTAPI_DISK_IS_MOUNTED = VixCOM.Constants.VIX_E_MNTAPI_DISK_IS_MOUNTED,
        /// <summary>
        /// Could not find the specified virtual disk.
        /// </summary>
        MNTAPI_DISK_NOT_FOUND = VixCOM.Constants.VIX_E_MNTAPI_DISK_NOT_FOUND,
        /// <summary>
        /// The specified disk is not mounted.
        /// </summary>
        MNTAPI_DISK_NOT_MOUNTED = VixCOM.Constants.VIX_E_MNTAPI_DISK_NOT_MOUNTED,
        /// <summary>
        /// It is not safe to mount the virtual disk. It may be attached to a suspended or powered-on VM, or it may be inside a snapshot chain.
        /// </summary>
        MNTAPI_DISK_NOT_SAFE = VixCOM.Constants.VIX_E_MNTAPI_DISK_NOT_SAFE,
        /// <summary>
        /// The specified drive letter is already assigned.
        /// </summary>
        MNTAPI_DRIVE_LETTER_ALREADY_ASSIGNED = VixCOM.Constants.VIX_E_MNTAPI_DRIVE_LETTER_ALREADY_ASSIGNED,
        /// <summary>
        /// The specified drive letter is already in use.
        /// </summary>
        MNTAPI_DRIVE_LETTER_IN_USE = VixCOM.Constants.VIX_E_MNTAPI_DRIVE_LETTER_IN_USE,
        /// <summary>
        /// Unable to format volume.
        /// </summary>
        MNTAPI_FORMAT_FAILURE = VixCOM.Constants.VIX_E_MNTAPI_FORMAT_FAILURE,
        /// <summary>
        /// Getfile error.
        /// </summary>
        MNTAPI_GETFILE_ERROR = VixCOM.Constants.VIX_E_MNTAPI_GETFILE_ERROR,
        /// <summary>
        /// The product version number is less than the expected version number.
        /// </summary>
        MNTAPI_INCOMPATIBLE_VERSION = VixCOM.Constants.VIX_E_MNTAPI_INCOMPATIBLE_VERSION,
        /// <summary>
        /// An internal error has occurred. Please contact VMware support.
        /// </summary>
        MNTAPI_INTERNAL = VixCOM.Constants.VIX_E_MNTAPI_INTERNAL,
        /// <summary>
        /// Invalid file - a required section of the file is missing.
        /// </summary>
        MNTAPI_ITEM_NOT_FOUND = VixCOM.Constants.VIX_E_MNTAPI_ITEM_NOT_FOUND,
        /// <summary>
        /// A loop device operation failed.
        /// </summary>
        MNTAPI_LOOP_FAILED = VixCOM.Constants.VIX_E_MNTAPI_LOOP_FAILED,
        /// <summary>
        /// The mountpoint is already in use.
        /// </summary>
        MNTAPI_MOUNTPT_IN_USE = VixCOM.Constants.VIX_E_MNTAPI_MOUNTPT_IN_USE,
        /// <summary>
        /// Could not find the specified mountpoint.
        /// </summary>
        MNTAPI_MOUNTPT_NOT_FOUND = VixCOM.Constants.VIX_E_MNTAPI_MOUNTPT_NOT_FOUND,
        /// <summary>
        /// Unable to get vixDiskLib connection details.
        /// </summary>
        MNTAPI_NO_CONNECTION_DETAILS = VixCOM.Constants.VIX_E_MNTAPI_NO_CONNECTION_DETAILS,
        /// <summary>
        /// Driver not found.
        /// </summary>
        MNTAPI_NO_DRIVER = VixCOM.Constants.VIX_E_MNTAPI_NO_DRIVER,
        MNTAPI_NO_MOUNTABLE_PARTITIONS = VixCOM.Constants.VIX_E_MNTAPI_NO_MOUNTABLE_PARTITONS,
        /// <summary>
        /// This application must be run setuid root.
        /// </summary>
        MNTAPI_NO_ROOT = VixCOM.Constants.VIX_E_MNTAPI_NO_ROOT,
        /// <summary>
        /// Failed to open DiskSet.
        /// </summary>
        MNTAPI_OPEN_FAILURE = VixCOM.Constants.VIX_E_MNTAPI_OPEN_FAILURE,
        /// <summary>
        /// Another process is performing an operation on this mounted virtual disk.
        /// </summary>
        MNTAPI_OPEN_HANDLES = VixCOM.Constants.VIX_E_MNTAPI_OPEN_HANDLES,
        /// <summary>
        /// The was an operating system specific error.
        /// </summary>
        MNTAPI_OS_ERROR = VixCOM.Constants.VIX_E_MNTAPI_OS_ERROR,
        /// <summary>
        /// The specified partition was not found.
        /// </summary>
        MNTAPI_PARTITION_NOT_FOUND = VixCOM.Constants.VIX_E_MNTAPI_PARTITION_NOT_FOUND,
        /// <summary>
        /// An invalid partition number was specified.
        /// </summary>
        MNTAPI_PARTITION_RANGE = VixCOM.Constants.VIX_E_MNTAPI_PARTITION_RANGE,
        /// <summary>
        /// Insufficient permissions to perform this operation.
        /// </summary>
        MNTAPI_PERM = VixCOM.Constants.VIX_E_MNTAPI_PERM,
        /// <summary>
        /// Putfile error.
        /// </summary>
        MNTAPI_PUTFILE_ERROR = VixCOM.Constants.VIX_E_MNTAPI_PUTFILE_ERROR,
        /// <summary>
        /// Unable to open registry key.
        /// </summary>
        MNTAPI_REG_NOT_OPENED = VixCOM.Constants.VIX_E_MNTAPI_REG_NOT_OPENED,
        /// <summary>
        /// There was an error deleting the registry key.
        /// </summary>
        MNTAPI_REGDELKEY_ERROR = VixCOM.Constants.VIX_E_MNTAPI_REGDELKEY_ERROR,
        /// <summary>
        /// There was an error writing to the registry.
        /// </summary>
        MNTAPI_REGWRITE_ERROR = VixCOM.Constants.VIX_E_MNTAPI_REGWRITE_ERROR,
        /// <summary>
        /// A system call has failed.
        /// </summary>
        MNTAPI_SYSTEM = VixCOM.Constants.VIX_E_MNTAPI_SYSTEM,
        /// <summary>
        /// umount command failed.
        /// </summary>
        MNTAPI_UMOUNT = VixCOM.Constants.VIX_E_MNTAPI_UMOUNT,
        /// <summary>
        /// Could not find the umount application in a standard system directory such as /bin /usr/bin or /sbin.
        /// </summary>
        MNTAPI_UMOUNT_APP_NOT_FOUND = VixCOM.Constants.VIX_E_MNTAPI_UMOUNT_APP_NOT_FOUND,
        /// <summary>
        /// Windows NT4 Fault Tolerant volume type is not supported.
        /// </summary>
        MNTAPI_UNSUPPORTED_FT_VOLUME = VixCOM.Constants.VIX_E_MNTAPI_UNSUPPORTED_FT_VOLUME,
        MNTAPI_UNSUPPORTED_BOOT_LOADER = VixCOM.Constants.VIX_E_MNTAPI_UNSUPPROTED_BOOT_LOADER,
        MNTAPI_UNSUPPORTED_OS = VixCOM.Constants.VIX_E_MNTAPI_UNSUPPROTED_OS,
        /// <summary>
        /// The specified volume is already mounted.
        /// </summary>
        MNTAPI_VOLUME_ALREADY_MOUNTED = VixCOM.Constants.VIX_E_MNTAPI_VOLUME_ALREADY_MOUNTED,
        /// <summary>
        /// The specified volume is not mounted.
        /// </summary>
        MNTAPI_VOLUME_NOT_MOUNTED = VixCOM.Constants.VIX_E_MNTAPI_VOLUME_NOT_MOUNTED,
        /// <summary>
        /// The volume is write-protected.
        /// </summary>
        MNTAPI_VOLUME_NOT_WRITABLE = VixCOM.Constants.VIX_E_MNTAPI_VOLUME_NOT_WRITABLE,
        #endregion

        #region NET_HTTP
        /// <summary>
        /// Failed to connect to host or proxy.
        /// </summary>
        NET_HTTP_COULDNT_CONNECT = VixCOM.Constants.VIX_E_NET_HTTP_COULDNT_CONNECT,
        /// <summary>
        /// Failed to resolve host.
        /// </summary>
        NET_HTTP_COULDNT_RESOLVE_HOST = VixCOM.Constants.VIX_E_NET_HTTP_COULDNT_RESOLVE_HOST,
        /// <summary>
        /// Failed to resolve proxy.
        /// </summary>
        NET_HTTP_COULDNT_RESOLVE_PROXY = VixCOM.Constants.VIX_E_NET_HTTP_COULDNT_RESOLVE_PROXY,
        /// <summary>
        /// A generic HTTP error occurred.
        /// </summary>
        NET_HTTP_GENERIC = VixCOM.Constants.VIX_E_NET_HTTP_GENERIC,
        /// <summary>
        /// Server returned HTTP error code >= 400.
        /// </summary>
        NET_HTTP_HTTP_RETURNED_ERROR = VixCOM.Constants.VIX_E_NET_HTTP_HTTP_RETURNED_ERROR,
        /// <summary>
        /// Network operation timed out.
        /// </summary>
        NET_HTTP_OPERATION_TIMEDOUT = VixCOM.Constants.VIX_E_NET_HTTP_OPERATION_TIMEDOUT,
        /// <summary>
        /// A problem occurred during the SSL/TLS handshake.
        /// </summary>
        NET_HTTP_SSL_CONNECT_ERROR = VixCOM.Constants.VIX_E_NET_HTTP_SSL_CONNECT_ERROR,
        /// <summary>
        /// An SSL error occurred.
        /// </summary>
        NET_HTTP_SSL_SECURITY = VixCOM.Constants.VIX_E_NET_HTTP_SSL_SECURITY,
        /// <summary>
        /// Hit the maximum number of redirects.
        /// </summary>
        NET_HTTP_TOO_MANY_REDIRECTS = VixCOM.Constants.VIX_E_NET_HTTP_TOO_MANY_REDIRECTS,
        /// <summary>
        /// Failure sending/receiving network data.
        /// </summary>
        NET_HTTP_TRANSFER = VixCOM.Constants.VIX_E_NET_HTTP_TRANSFER,
        /// <summary>
        /// The URL you passed in used a protocol that is not supported.
        /// </summary>
        NET_HTTP_UNSUPPORTED_PROTOCOL = VixCOM.Constants.VIX_E_NET_HTTP_UNSUPPORTED_PROTOCOL,
        /// <summary>
        /// The URL was not properly formatted.
        /// </summary>
        NET_HTTP_URL_MALFORMAT = VixCOM.Constants.VIX_E_NET_HTTP_URL_MALFORMAT,
        #endregion

        #region Wrapper Errors
        /// <summary>
        /// Service type <see cref="VIX_SERVICEPROVIDER.VMWARE_WORKSTATION"/> was specified, but not installed.
        /// </summary>
        WRAPPER_WORKSTATION_NOT_INSTALLED = VixCOM.Constants.VIX_E_WRAPPER_WORKSTATION_NOT_INSTALLED,
        /// <summary>
        /// The specified version was not found.
        /// </summary>
        WRAPPER_VERSION_NOT_FOUND = VixCOM.Constants.VIX_E_WRAPPER_VERSION_NOT_FOUND,
        /// <summary>
        /// The specified service provider was not found.
        /// </summary>
        WRAPPER_SERVICEPROVIDER_NOT_FOUND = VixCOM.Constants.VIX_E_WRAPPER_SERVICEPROVIDER_NOT_FOUND,
        /// <summary>
        /// Cannot find support libraries; Vix appears to have not been installed.
        /// </summary>
        WRAPPER_RUNTIME_NOT_INSTALLED = VixCOM.Constants.VIX_E_WRAPPER_RUNTIME_NOT_INSTALLED,
        /// <summary>
        /// Service type <see cref="VIX_SERVICEPROVIDER.VMWARE_PLAYER"/> was specified, but not installed.
        /// </summary>
        WRAPPER_PLAYER_NOT_INSTALLED = VixCOM.Constants.VIX_E_WRAPPER_PLAYER_NOT_INSTALLED,
        /// <summary>
        /// Cannot connect with multiple service providers.
        /// </summary>
        WRAPPER_MULTIPLE_SERVICEPROVIDERS = VixCOM.Constants.VIX_E_WRAPPER_MULTIPLE_SERVICEPROVIDERS,
        #endregion
    }

    /// <summary>
    /// Enumeration of different event-types.
    /// </summary>
    public enum VIX_EVENTTYPE
    {
        JOB_COMPLETED = VixCOM.Constants.VIX_EVENTTYPE_JOB_COMPLETED,
        JOB_PROGRESS = VixCOM.Constants.VIX_EVENTTYPE_JOB_PROGRESS,
        FIND_ITEM = VixCOM.Constants.VIX_EVENTTYPE_FIND_ITEM,
        [Obsolete("Deprecated - Use VIX_EVENTTYPE_JOB_COMPLETED instead.")]
        CALLBACK_SIGNALLED = VixCOM.Constants.VIX_EVENTTYPE_CALLBACK_SIGNALLED
    }

    /// <summary>
    /// Enumeration of different file attributes.
    /// </summary>
    public enum VIX_FILE_ATTRIBUTES
    {
        DIRECTORY = VixCOM.Constants.VIX_FILE_ATTRIBUTES_DIRECTORY,
        SYMLINK = VixCOM.Constants.VIX_FILE_ATTRIBUTES_SYMLINK
    }

    /// <summary>
    /// These are the types of searches you can do with <see cref="Host.FindItems"/>.
    /// </summary>
    public enum VIX_FIND
    {
        /// <summary>
        /// Finds all virtual machines currently running on the host.
        /// </summary>
        RUNNING_VMS = VixCOM.Constants.VIX_FIND_RUNNING_VMS,
        /// <summary>
        /// Finds all virtual machines registered on the host. This search applies only to platform products that maintain a virtual machine registry, such as ESX/ESXi and VMware Server, but not Workstation or Player.
        /// </summary>
        REGISTERED_VMS = VixCOM.Constants.VIX_FIND_REGISTERED_VMS
    }

    /// <summary>
    /// These are the types of handles used as values for VixHandle variables. Handle types are returned by the GetHandleType() function. Handles are used to manage the entities they represent (such as virtual machines) and to retrieve properties representing information about the entities. 
    /// </summary>
    public enum VIX_HANDLETYPE
    {
        /// <summary>
        /// Indicates that no value has been assigned to this handle. Recommended for initializing handle variables.
        /// </summary>
        NONE = VixCOM.Constants.VIX_HANDLETYPE_NONE,
        /// <summary>
        /// The handle represents a host. This handle type is created when you call VixHost_Connect().
        /// </summary>
        HOST = VixCOM.Constants.VIX_HANDLETYPE_HOST,
        /// <summary>
        /// The handle represents a virtual machine. This handle type is created when you call VixVM_Open().
        /// </summary>
        VM = VixCOM.Constants.VIX_HANDLETYPE_VM,
        NETWORK = VixCOM.Constants.VIX_HANDLETYPE_NETWORK,
        METADATA_CONTAINER = VixCOM.Constants.VIX_HANDLETYPE_METADATA_CONTAINER,
        /// <summary>
        /// The handle represents an active job. Job handles are return values from asynchronous operations, including VixHost_Connect() and VixVM_Open()
        /// </summary>
        JOB = VixCOM.Constants.VIX_HANDLETYPE_JOB,
        /// <summary>
        /// The handle represents a snapshot. This handle type is created when you call snapshot functions such as VixVM_GetCurrentSnapshot(). Use these handles to revert or remove snapshots.
        /// </summary>
        SNAPSHOT = VixCOM.Constants.VIX_HANDLETYPE_SNAPSHOT,
        /// <summary>
        /// The handle represents a property list. This handle type is used to pass additional arguments to many functions.  
        /// </summary>
        PROPERY_LIST = VixCOM.Constants.VIX_HANDLETYPE_PROPERTY_LIST
    }

    /// <summary>
    /// These are the types used for the InstallTools() function.
    /// </summary>
    [Flags]
    public enum VIX_INSTALLTOOLS
    {
        AUTO_UPGRADE = VixCOM.Constants.VIX_INSTALLTOOLS_AUTO_UPGRADE,
        MOUNT_TOOLS_INSTALLER = VixCOM.Constants.VIX_INSTALLTOOLS_MOUNT_TOOLS_INSTALLER,
        RETURN_IMMEDIATELY = VixCOM.Constants.VIX_INSTALLTOOLS_RETURN_IMMEDIATELY
    }

    /// <summary>
    /// <para>These are the possible values reported for <see cref="VIX_PROPERTY.VM_POWER_STATE"/>.</para>
    /// <para>They represent runtime information about the state of the virtual machine.</para>
    /// <para>To test the value of the property, use the <see cref="VM.GetProperties"/> function.</para>
    /// </summary>
    [Flags]
    public enum VIX_POWERSTATE
    {
        /// <summary>
        /// Indicates that a virtual machine state change is blocked, waiting for user interaction.
        /// </summary>
        BLOCKED_ON_MSG = VixCOM.Constants.VIX_POWERSTATE_BLOCKED_ON_MSG,
        PAUSED = VixCOM.Constants.VIX_POWERSTATE_PAUSED,
        /// <summary>
        /// Indicates that the virtual machine is not running.
        /// </summary>
        POWERED_OFF = VixCOM.Constants.VIX_POWERSTATE_POWERED_OFF,
        /// <summary>
        /// Indicates that the virtual machine is running.
        /// </summary>
        POWERED_ON = VixCOM.Constants.VIX_POWERSTATE_POWERED_ON,
        /// <summary>
        /// Indicates that <see cref="VM.PowerOff(VIX_VMPOWEROP)"/> has been called, but the operation itself has not completed.
        /// </summary>
        POWERING_OFF = VixCOM.Constants.VIX_POWERSTATE_POWERING_OFF,
        /// <summary>
        /// Indicates that <see cref="VM.PowerOn(VIX_VMPOWEROP)"/> has been called, but the operation itself has not completed.
        /// </summary>
        POWERING_ON = VixCOM.Constants.VIX_POWERSTATE_POWERING_ON,
        /// <summary>
        /// Indicates that <see cref="VM.Reset"/> has been called, but the operation itself has not completed.
        /// </summary>
        RESETTING = VixCOM.Constants.VIX_POWERSTATE_RESETTING,
        RESUMING = VixCOM.Constants.VIX_POWERSTATE_RESUMING,
        /// <summary>
        /// Indicates that the virtual machine is suspended. Use <see cref="VM.PowerOn(VIX_VMPOWEROP)"/> to resume the virtual machine.
        /// </summary>
        SUSPENDED = VixCOM.Constants.VIX_POWERSTATE_SUSPENDED,
        /// <summary>
        /// Indicates that <see cref="VM.Suspend"/> has been called, but the operation itself has not completed.
        /// </summary>
        SUSPENDING = VixCOM.Constants.VIX_POWERSTATE_SUSPENDING,
        /// <summary>
        /// Indicates that the virtual machine is running and the VMware Tools suite is active. See also the <see cref="VIX_PROPERTY.VM_TOOLS_STATE"/> property.
        /// </summary>
        TOOLS_RUNNING = VixCOM.Constants.VIX_POWERSTATE_TOOLS_RUNNING,
        /// <summary>
        /// When you retrieve the power state of a VM with the GetProperties() function, sometimes there is a bit set in the bitmask which is not explained in the documentation.
        /// </summary>
        /// <remarks>
        /// <para>The bit is included in the enumeration to get a nice formatted String when calling the ToString() method of the enumeration.</para>
        /// </remarks>
        // TODO: investigate why this bit is sometimes set
        UNKNOWN_BIT = 1024
    }

    /// <summary>
    /// VIX Property ID's.
    /// </summary>
    public enum VIX_PROPERTY
    {
        /// <summary>
        /// Indicates that no value has been assigned to this property variable. Recommended for initializing property variables.
        /// </summary>
        NONE = VixCOM.Constants.VIX_PROPERTY_NONE,

        #region Guest properties
        GUEST_SHAREDFOLDERS_SHARES_PATH = VixCOM.Constants.VIX_PROPERTY_GUEST_SHAREDFOLDERS_SHARES_PATH,
        #endregion

        #region Properties used by several handle types
        META_DATA_CONTAINER = VixCOM.Constants.VIX_PROPERTY_META_DATA_CONTAINER,
        #endregion

        #region VIX_HANDLETYPE_HOST properties
        HOST_HOSTTYPE = VixCOM.Constants.VIX_PROPERTY_HOST_HOSTTYPE,
        HOST_API_VERSION = VixCOM.Constants.VIX_PROPERTY_HOST_API_VERSION,
        #endregion

        #region VIX_HANDLETYPE_VM properties
        /// <summary>
        /// Virtual machine name.
        /// </summary>
        VM_NAME = VixCOM.Constants.VIX_PROPERTY_VM_NAME,
        /// <summary>
        /// Virtual machine encryption password.
        /// </summary>
        VM_ENCRYPTION_PASSWORD = VixCOM.Constants.VIX_PROPERTY_VM_ENCRYPTION_PASSWORD,
        /// <summary>
        /// Virutal machine guest OS.
        /// </summary>
        VM_GUESTOS = VixCOM.Constants.VIX_PROPERTY_VM_GUESTOS,
        /// <summary>
        /// The number of virtual CPUs configured for the virtual machine.
        /// </summary>
        VM_NUM_VCPUS = VixCOM.Constants.VIX_PROPERTY_VM_NUM_VCPUS,
        /// <summary>
        /// The path to the virtual machine configuration file.
        /// </summary>
        VM_VMX_PATHNAME = VixCOM.Constants.VIX_PROPERTY_VM_VMX_PATHNAME,
        /// <summary>
        /// The path to the virtual machine team.
        /// </summary>
        VM_VMTEAM_PATHNAME = VixCOM.Constants.VIX_PROPERTY_VM_VMTEAM_PATHNAME,
        /// <summary>
        /// The memory size of the virtual machine.
        /// </summary>
        VM_MEMORY_SIZE = VixCOM.Constants.VIX_PROPERTY_VM_MEMORY_SIZE,
        VM_READ_ONLY = VixCOM.Constants.VIX_PROPERTY_VM_READ_ONLY,
        /// <summary>
        /// Whether the virtual machine is a member of a team.
        /// </summary>
        VM_IN_VMTEAM = VixCOM.Constants.VIX_PROPERTY_VM_IN_VMTEAM,
        /// <summary>
        /// The power state of the virtual machine. For a list of values, see <see cref="VIX_POWERSTATE"/>.
        /// </summary>
        VM_POWER_STATE = VixCOM.Constants.VIX_PROPERTY_VM_POWER_STATE,
        /// <summary>
        /// The state of the VMware Tools suite in the guest.
        /// </summary>
        VM_TOOLS_STATE = VixCOM.Constants.VIX_PROPERTY_VM_TOOLS_STATE,
        /// <summary>
        /// Whether the virtual machine is running.
        /// </summary>
        VM_IS_RUNNING = VixCOM.Constants.VIX_PROPERTY_VM_IS_RUNNING,
        VM_SUPPORTED_FEATURES = VixCOM.Constants.VIX_PROPERTY_VM_SUPPORTED_FEATURES,
        /// <summary>
        /// Whether the virtual machine is recording.
        /// </summary>
        VM_IS_RECORDING = VixCOM.Constants.VIX_PROPERTY_VM_IS_RECORDING,
        /// <summary>
        /// Whether the virtual machine is replaying.
        /// </summary>
        VM_IS_REPLAYING = VixCOM.Constants.VIX_PROPERTY_VM_IS_REPLAYING,
        #endregion

        #region Result properties; these are returned by various procedures
        /// <summary>
        /// Extra error informations.
        /// </summary>
        JOB_RESULT_EXTRA_ERROR_INFO = VixCOM.Constants.VIX_PROPERTY_JOB_RESULT_EXTRA_ERROR_INFO,
        /// <summary>
        /// The most recent error encountered by the job.
        /// </summary>
        JOB_RESULT_ERROR_CODE = VixCOM.Constants.VIX_PROPERTY_JOB_RESULT_ERROR_CODE,
        JOB_RESULT_VM_IN_GROUP = VixCOM.Constants.VIX_PROPERTY_JOB_RESULT_VM_IN_GROUP,
        /// <summary>
        /// A user message blocking the virtual machine.
        /// </summary>
        JOB_RESULT_USER_MESSAGE = VixCOM.Constants.VIX_PROPERTY_JOB_RESULT_USER_MESSAGE,
        JOB_RESULT_EXIT_CODE = VixCOM.Constants.VIX_PROPERTY_JOB_RESULT_EXIT_CODE,
        JOB_RESULT_COMMAND_OUTPUT = VixCOM.Constants.VIX_PROPERTY_JOB_RESULT_COMMAND_OUTPUT,
        /// <summary>
        /// A handle resulting from an asynchronous operation.
        /// </summary>
        JOB_RESULT_HANDLE = VixCOM.Constants.VIX_PROPERTY_JOB_RESULT_HANDLE,
        JOB_RESULT_GUEST_OBJECT_EXISTS = VixCOM.Constants.VIX_PROPERTY_JOB_RESULT_GUEST_OBJECT_EXISTS,
        /// <summary>
        /// The time it took to execute a program with <see cref="VM.RunProgramInGuest"/>.
        /// </summary>
        JOB_RESULT_GUEST_PROGRAM_ELAPSED_TIME = VixCOM.Constants.VIX_PROPERTY_JOB_RESULT_GUEST_PROGRAM_ELAPSED_TIME,
        /// <summary>
        /// The exit code resulting from <see cref="VM.RunProgramInGuest"/>.
        /// </summary>
        JOB_RESULT_GUEST_PROGRAM_EXIT_CODE = VixCOM.Constants.VIX_PROPERTY_JOB_RESULT_GUEST_PROGRAM_EXIT_CODE,
        /// <summary>
        /// For VixJob_GetNthProperties(), the name of an item found.
        /// </summary>
        JOB_RESULT_ITEM_NAME = VixCOM.Constants.VIX_PROPERTY_JOB_RESULT_ITEM_NAME,
        /// <summary>
        /// For VixJob_GetNthProperties(), the description of an item found.
        /// </summary>
        JOB_RESULT_FOUND_ITEM_DESCRIPTION = VixCOM.Constants.VIX_PROPERTY_JOB_RESULT_FOUND_ITEM_DESCRIPTION,
        JOB_RESULT_SHARED_FOLDER_COUNT = VixCOM.Constants.VIX_PROPERTY_JOB_RESULT_SHARED_FOLDER_COUNT,
        JOB_RESULT_SHARED_FOLDER_HOST = VixCOM.Constants.VIX_PROPERTY_JOB_RESULT_SHARED_FOLDER_HOST,
        JOB_RESULT_SHARED_FOLDER_FLAGS = VixCOM.Constants.VIX_PROPERTY_JOB_RESULT_SHARED_FOLDER_FLAGS,
        JOB_RESULT_PROCESS_ID = VixCOM.Constants.VIX_PROPERTY_JOB_RESULT_PROCESS_ID,
        JOB_RESULT_PROCESS_OWNER = VixCOM.Constants.VIX_PROPERTY_JOB_RESULT_PROCESS_OWNER,
        JOB_RESULT_PROCESS_COMMAND = VixCOM.Constants.VIX_PROPERTY_JOB_RESULT_PROCESS_COMMAND,
        JOB_RESULT_FILE_FLAGS = VixCOM.Constants.VIX_PROPERTY_JOB_RESULT_FILE_FLAGS,
        JOB_RESULT_PROCESS_START_TIME = VixCOM.Constants.VIX_PROPERTY_JOB_RESULT_PROCESS_START_TIME,
        JOB_RESULT_VM_VARIABLE_STRING = VixCOM.Constants.VIX_PROPERTY_JOB_RESULT_VM_VARIABLE_STRING,
        JOB_RESULT_PROCESS_BEING_DEBUGGED = VixCOM.Constants.VIX_PROPERTY_JOB_RESULT_PROCESS_BEING_DEBUGGED,
        /// <summary>
        /// An integer property containing the size of the image, in bytes.
        /// </summary>
        JOB_RESULT_SCREEN_IMAGE_SIZE = VixCOM.Constants.VIX_PROPERTY_JOB_RESULT_SCREEN_IMAGE_SIZE,
        /// <summary>
        /// A Blob property containing the screen image.
        /// </summary>
        JOB_RESULT_SCREEN_IMAGE_DATA = VixCOM.Constants.VIX_PROPERTY_JOB_RESULT_SCREEN_IMAGE_DATA,
        /// <summary>
        /// An integer property containing the size of the image, in bytes.
        /// </summary>
        JOB_RESULT_FILE_SIZE = VixCOM.Constants.VIX_PROPERTY_JOB_RESULT_FILE_SIZE,
        JOB_RESULT_FILE_MOD_TIME = VixCOM.Constants.VIX_PROPERTY_JOB_RESULT_FILE_MOD_TIME,
        #endregion

        #region Event properties; these are sent in the moreEventInfo for some events
        FOUND_ITEM_LOCATION = VixCOM.Constants.VIX_PROPERTY_FOUND_ITEM_LOCATION,
        #endregion

        #region VIX_HANDLETYPE_SNAPSHOT properties
        /// <summary>
        /// User defined name for the snapshot.
        /// </summary>
        SNAPSHOT_DISPLAYNAME = VixCOM.Constants.VIX_PROPERTY_SNAPSHOT_DISPLAYNAME,
        /// <summary>
        /// User defined description for the snapshot.
        /// </summary>
        SNAPSHOT_DESCRIPTION = VixCOM.Constants.VIX_PROPERTY_SNAPSHOT_DESCRIPTION,
        SNAPSHOT_POWERSTATE = VixCOM.Constants.VIX_PROPERTY_SNAPSHOT_POWERSTATE,
        /// <summary>
        /// Whether the snapshot is replayable.
        /// </summary>
        SNAPSHOT_IS_REPLAYABLE = VixCOM.Constants.VIX_PROPERTY_SNAPSHOT_IS_REPLAYABLE
        #endregion
    }

    /// <summary>
    /// These are the possible types for Vix properties. Property types are returned by the GetPropertyType() function.
    /// </summary>
    public enum VIX_PROPERTYTYPE
    {
        /// <summary>
        /// Indicates that no property type has been assigned to this variable. Recommended for initializing property type variables.
        /// </summary>
        ANY = VixCOM.Constants.VIX_PROPERTYTYPE_ANY,
        /// <summary>
        /// The property type is 'int'.
        /// </summary>
        INTEGER = VixCOM.Constants.VIX_PROPERTYTYPE_INTEGER,
        /// <summary>
        /// The property type is 'char *'.
        /// </summary>
        STRING = VixCOM.Constants.VIX_PROPERTYTYPE_STRING,
        /// <summary>
        /// The property type is Boolean.
        /// </summary>
        BOOL = VixCOM.Constants.VIX_PROPERTYTYPE_BOOL,
        /// <summary>
        /// The property type is VixHandle.
        /// </summary>
        HANDLE = VixCOM.Constants.VIX_PROPERTYTYPE_HANDLE,
        /// <summary>
        /// The property type is 'int64'.
        /// </summary>
        INT64 = VixCOM.Constants.VIX_PROPERTYTYPE_INT64,
        /// <summary>
        /// The property type is 'char *". When returned as a job property, the blob is returned as two values: first an 'int' containing the blob size in bytes, then a pointer to the blob.
        /// </summary>
        BLOB = VixCOM.Constants.VIX_PROPERTYTYPE_BLOB
    }

    /// <summary>
    /// Used for the RunProgramInGuest() function.
    /// </summary>
    [Flags]
    public enum VIX_RUNPROGRAM
    {
        ACTIVATE_WINDOW = VixCOM.Constants.VIX_RUNPROGRAM_ACTIVATE_WINDOW,
        RETURN_IMMEDIATELY = VixCOM.Constants.VIX_RUNPROGRAM_RETURN_IMMEDIATELY
    }

    /// <summary>
    /// Enumeration of different VMware products.
    /// </summary>
    public enum VIX_SERVICEPROVIDER
    {
        /// <summary>
        /// Use this if you do not know which VMware product will be running on the host.
        /// </summary>
        DEFAULT = VixCOM.Constants.VIX_SERVICEPROVIDER_DEFAULT,
        /// <summary>
        /// Use for VMware Server 1.x hosts
        /// </summary>
        VMWARE_SERVER = VixCOM.Constants.VIX_SERVICEPROVIDER_VMWARE_SERVER,
        /// <summary>
        /// Use for Workstation 6.x or later hosts
        /// </summary>
        VMWARE_WORKSTATION = VixCOM.Constants.VIX_SERVICEPROVIDER_VMWARE_WORKSTATION,
        /// <summary>
        /// Use for VMware Server 2.x or ESX/ESXi hosts. You need at least VMware ESX 3.5 U2 or later.
        /// </summary>
        VMWARE_VI_SERVER = VixCOM.Constants.VIX_SERVICEPROVIDER_VMWARE_VI_SERVER,
        /// <summary>
        /// Use for VMware Player hosts
        /// </summary>
        VMWARE_PLAYER = VixCOM.Constants.VIX_SERVICEPROVIDER_VMWARE_PLAYER
    }

    /// <summary>
    /// Types for snapshots.
    /// </summary>
    public enum VIX_SNAPSHOT
    {
        /// <summary>
        /// Captures the full state of a running virtual machine, including the memory.
        /// </summary>
        INCLUDE_MEMORY = VixCOM.Constants.VIX_SNAPSHOT_INCLUDE_MEMORY,
        /// <summary>
        /// Remove snapshots that are children of the given snapshot.
        /// </summary>
        REMOVE_CHILDREN = VixCOM.Constants.VIX_SNAPSHOT_REMOVE_CHILDREN
    }

    /// <summary>
    /// <para>These are the possible values reported for <see cref="VIX_PROPERTY.VM_TOOLS_STATE"/>.</para>
    /// <para>They represent runtime information about the VMware Tools suite in the guest operating system.</para>
    /// <para>To test the value of the property, use the <see cref="VM.GetProperties"/> function.</para>
    /// </summary>
    public enum VIX_TOOLSSTATE
    {
        /// <summary>
        /// Indicates that Vix is unable to determine the VMware Tools status.
        /// </summary>
        UNKNOWN = VixCOM.Constants.VIX_TOOLSSTATE_UNKNOWN,
        /// <summary>
        /// Indicates that VMware Tools is not installed in the guest operating system.
        /// </summary>
        RUNNING = VixCOM.Constants.VIX_TOOLSSTATE_RUNNING,
        /// <summary>
        /// Indicates that VMware Tools is running in the guest operating system.
        /// </summary>
        NOT_INSTALLED = VixCOM.Constants.VIX_TOOLSSTATE_NOT_INSTALLED
    }

    /// <summary>
    /// Enumeration of VM variables.
    /// </summary>
    public enum VIX_VM
    {
        /// <summary>
        /// The configuration state of the virtual machine. This is the .vmx file that is stored on the host. You can read this and it will return the persistent data. If you write to this, it will only be a runtime change, so changes will be lost when the VM powers off.
        /// </summary>
        CONFIG_RUNTIME_ONLY = VixCOM.Constants.VIX_VM_CONFIG_RUNTIME_ONLY,
        /// <summary>
        /// A "Guest Variable". This is a runtime-only value; it is never stored persistently. This is the same guest variable that is exposed through the VMControl APIs, and is a simple way to pass runtime values in and out of the guest.
        /// </summary>
        GUEST_VARIABLE = VixCOM.Constants.VIX_VM_GUEST_VARIABLE
    }

    /// <summary>
    /// These flags describe optional functions supported by different types of VM.
    /// </summary>
    [Flags]
    public enum VIX_VM_SUPPORT
    {
        HARDWARE_UPGRADE = VixCOM.Constants.VIX_VM_SUPPORT_HARDWARE_UPGRADE,
        MULTIPLE_SNAPSHOTS = VixCOM.Constants.VIX_VM_SUPPORT_MULTIPLE_SNAPSHOTS,
        SHARED_FOLDERS = VixCOM.Constants.VIX_VM_SUPPORT_SHARED_FOLDERS,
        TOOLS_INSTALL = VixCOM.Constants.VIX_VM_SUPPORT_TOOLS_INSTALL
    }

    /// <summary>
    /// Virtual Machine power options.
    /// </summary>
    // TODO: not sure if this enumeration is used as a bitmask...
    // [Flags]
    public enum VIX_VMPOWEROP
    {
        /// <summary>
        /// To display a virtual machine with a Workstation user interface, powerOnOptions must have the LAUNCH_GUI flag.
        /// </summary>
        /// <remarks>
        /// If there is an existing instance of the Workstation user interface, the virtual machine will power on in a new tab within that instance. Otherwise, a new instance of Workstation will open, and the virtual machine will power on there. 
        /// </remarks>
        LAUNCH_GUI = VixCOM.Constants.VIX_VMPOWEROP_LAUNCH_GUI,

        /// <summary>
        /// This flag will cause the function to try to power off the guest OS. This will ensure a clean shutdown of the guest. This option requires that the VMware Tools be installed and running in the guest. 
        /// </summary>
        FROM_GUEST = VixCOM.Constants.VIX_VMPOWEROP_FROM_GUEST,

        /// <summary>
        /// If this is passed as parameter in the <see cref="VM.PowerOff"/> function, the virtual machine will be powered off at the hardware level. Any state of the guest that has not been committed to disk will be lost.
        /// If this is passed as parameter in the <see cref="VM.PowerOn(VIX_VMPOWEROP)"/> function, the virtual machine will be powered on normally.
        /// If this is passed as parameter in the <see cref="VM.Reset"/> function, it is the equivalent of pressing the reset button on a physical machine.
        /// </summary>
        NORMAL = VixCOM.Constants.VIX_VMPOWEROP_NORMAL,

        /// <summary>
        /// To record the virtual machine from the beginning when recording with the <see cref="VM.BeginRecording"/> function.
        /// </summary>
        START_VM_PAUSED = VixCOM.Constants.VIX_VMPOWEROP_START_VM_PAUSED,

        /// <summary>
        /// For use in the <see cref="VM.RevertToSnapshot"/> function: To prevent the virtual machine from being powered on regardless of the power state when the snapshot was created.
        /// </summary>
        SUPPRESS_SNAPSHOT_POWERON = VixCOM.Constants.VIX_VMPOWEROP_SUPPRESS_SNAPSHOT_POWERON
    }
    #endregion
}

